const mysql = require('mysql2/promise');
const fs = require('fs').promises;
const path = require('path');

// 数据库配置
const dbConfig = {
    host: process.env.DB_HOST || '43.143.253.188',
    port: parseInt(process.env.DB_PORT) || 3306,
    user: process.env.DB_USER || 'nextjs',
    password: process.env.DB_PASS || 'yEAiRE2jcxTyRBy5',
    database: process.env.DB_NAME || 'nextjs',
    timezone: '+08:00'
};

// 解析范围字段（如 "63-73" 转换为 min: 63, max: 73）
function parseRange(rangeStr) {
    if (!rangeStr || typeof rangeStr !== 'string') {
        return { min: 0, max: 0 };
    }

    const parts = rangeStr.split('-');
    if (parts.length !== 2) {
        console.warn(`⚠️  无法解析范围字段: ${rangeStr}，使用默认值 0-0`);
        return { min: 0, max: 0 };
    }

    const min = parseInt(parts[0].trim());
    const max = parseInt(parts[1].trim());

    if (isNaN(min) || isNaN(max)) {
        console.warn(`⚠️  范围字段包含非数字: ${rangeStr}，使用默认值 0-0`);
        return { min: 0, max: 0 };
    }

    return { min, max };
}

// 解析成长率范围字段（如 "1.1-1.3" 转换为 min: 1.10, max: 1.30）
function parseGrowthRate(rangeStr) {
    if (!rangeStr || typeof rangeStr !== 'string') {
        return { min: 0.00, max: 0.00 };
    }

    const parts = rangeStr.split('-');
    if (parts.length !== 2) {
        console.warn(`⚠️  无法解析成长率范围字段: ${rangeStr}，使用默认值 0.00-0.00`);
        return { min: 0.00, max: 0.00 };
    }

    const min = parseFloat(parts[0].trim());
    const max = parseFloat(parts[1].trim());

    if (isNaN(min) || isNaN(max)) {
        console.warn(`⚠️  成长率范围字段包含非数字: ${rangeStr}，使用默认值 0.00-0.00`);
        return { min: 0.00, max: 0.00 };
    }

    return { min, max };
}

// 转换数据格式
function transformData(item) {
    const apRange = parseRange(item.ap);
    const czlRange = parseGrowthRate(item.czl);
    const hpRange = parseRange(item.hp);
    const mpRange = parseRange(item.mp);
    const spRange = parseRange(item.sp);

    return {
        name: item.name,
        description: item.descr || '',
        star_level: item.s || 1,
        ap_min: apRange.min,
        ap_max: apRange.max,
        czl_min: czlRange.min,
        czl_max: czlRange.max,
        hp_min: hpRange.min,
        hp_max: hpRange.max,
        mp_min: mpRange.min,
        mp_max: mpRange.max,
        sp_min: spRange.min,
        sp_max: spRange.max
    };
}

// 插入数据到数据库
async function insertData(connection, data) {
    const sql = `
    INSERT INTO deputy_general_base (
      name, description, star_level,
      ap_min, ap_max, czl_min, czl_max,
      hp_min, hp_max, mp_min, mp_max,
      sp_min, sp_max
    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    ON DUPLICATE KEY UPDATE
      description = VALUES(description),
      star_level = VALUES(star_level),
      ap_min = VALUES(ap_min),
      ap_max = VALUES(ap_max),
      czl_min = VALUES(czl_min),
      czl_max = VALUES(czl_max),
      hp_min = VALUES(hp_min),
      hp_max = VALUES(hp_max),
      mp_min = VALUES(mp_min),
      mp_max = VALUES(mp_max),
      sp_min = VALUES(sp_min),
      sp_max = VALUES(sp_max),
      updated_at = CURRENT_TIMESTAMP
  `;

    const values = [
        data.name, data.description, data.star_level,
        data.ap_min, data.ap_max, data.czl_min, data.czl_max,
        data.hp_min, data.hp_max, data.mp_min, data.mp_max,
        data.sp_min, data.sp_max
    ];

    try {
        const [result] = await connection.execute(sql, values);
        if (result.affectedRows > 0) {
            if (result.insertId) {
                console.log(`✅ 插入成功: ${data.name} (ID: ${result.insertId})`);
            } else {
                console.log(`🔄 更新成功: ${data.name}`);
            }
        }
        return result;
    } catch (error) {
        console.error(`❌ 插入/更新失败: ${data.name} - ${error.message}`);
        throw error;
    }
}

// 主函数
async function importDeputyGeneralData() {
    let connection;

    try {
        console.log('🚀 开始导入副将数据...');
        console.log(`📊 数据库配置: ${dbConfig.host}:${dbConfig.port}/${dbConfig.database}`);

        // 连接数据库
        console.log('🔌 连接数据库...');
        connection = await mysql.createConnection(dbConfig);
        console.log('✅ 数据库连接成功');

        // 检查表是否存在
        console.log('🔍 检查表结构...');
        const [tables] = await connection.execute(`
      SELECT COUNT(*) as count 
      FROM information_schema.tables 
      WHERE table_schema = ? AND table_name = 'deputy_general_base'
    `, [dbConfig.database]);

        if (tables[0].count === 0) {
            console.error('❌ 表 deputy_general_base 不存在，请先创建表');
            return;
        }
        console.log('✅ 表 deputy_general_base 存在');

        // 读取JSON文件
        console.log('📖 读取数据文件...');
        const jsonPath = path.join(__dirname, 'websocket_data_2025-08-27T09-19-03-318Z.json');
        const jsonData = await fs.readFile(jsonPath, 'utf8');
        const data = JSON.parse(jsonData);

        console.log(`📋 读取到 ${data.length} 条数据`);

        // 过滤出有效的副将数据（有name字段的数据）
        const validData = data.filter(item => item.name && item.name.trim());
        console.log(`✅ 有效数据: ${validData.length} 条`);

        if (validData.length === 0) {
            console.log('⚠️  没有找到有效数据，退出');
            return;
        }

        // 转换数据格式
        console.log('🔄 转换数据格式...');
        const transformedData = validData.map(transformData);

        // 开始导入数据
        console.log('📥 开始导入数据...');
        let successCount = 0;
        let errorCount = 0;

        for (let i = 0; i < transformedData.length; i++) {
            const item = transformedData[i];
            try {
                await insertData(connection, item);
                successCount++;

                // 每100条显示进度
                if ((i + 1) % 100 === 0) {
                    console.log(`📊 进度: ${i + 1}/${transformedData.length} (${Math.round((i + 1) / transformedData.length * 100)}%)`);
                }
            } catch (error) {
                errorCount++;
                console.error(`❌ 处理数据失败: ${item.name} - ${error.message}`);
            }
        }

        // 显示导入结果
        console.log('\n📊 导入完成！');
        console.log(`✅ 成功: ${successCount} 条`);
        console.log(`❌ 失败: ${errorCount} 条`);
        console.log(`📋 总计: ${transformedData.length} 条`);

        // 验证导入结果
        console.log('\n🔍 验证导入结果...');
        const [countResult] = await connection.execute('SELECT COUNT(*) as total FROM deputy_general_base');
        console.log(`📊 表中总记录数: ${countResult[0].total}`);

    } catch (error) {
        console.error('❌ 导入过程中发生错误:', error.message);
        console.error(error.stack);
    } finally {
        if (connection) {
            try {
                await connection.end();
                console.log('🔌 数据库连接已关闭');
            } catch (error) {
                console.error('⚠️  关闭数据库连接时发生错误:', error.message);
            }
        }
    }
}

// 运行导入
if (require.main === module) {
    importDeputyGeneralData()
        .then(() => {
            console.log('🎉 导入脚本执行完成');
            process.exit(0);
        })
        .catch((error) => {
            console.error('💥 导入脚本执行失败:', error.message);
            process.exit(1);
        });
}

module.exports = { importDeputyGeneralData, transformData }; 